rochars / wavefile

 * Copyright (c) 2017-2019 Rafael da Silva Rocha.

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 */

/**

 * @fileoverview The WaveFileReader class.

 * @see https://github.com/rochars/wavefile

 */

import { RIFFFile } from "./riff-file";

import { unpackString, unpack } from "./parsers/binary";

/**

 * A class to read wav files.

 * @extends RIFFFile

 */

export class WaveFileReader extends RIFFFile {

  /**

   * Set up the WaveFileReader object from a wav byte buffer.

   * @param {!Uint8Array} wavBuffer The buffer.

   * @param {boolean=} [samples=true] True if the samples should be loaded.

   * @throws {Error} If container is not RIFF, RIFX or RF64.

   * @throws {Error} If format is not WAVE.

   * @throws {Error} If no 'fmt ' chunk is found.

   * @throws {Error} If no 'data' chunk is found.

   */

  fromBuffer(wavBuffer, samples = true) {

    // Always should reset the chunks when reading from a buffer

    this.clearHeaders();

    this.setSignature(wavBuffer);

    this.uInt16.be = this.uInt32.be;

    if (this.format != "WAVE") {

      throw Error('Could not find the "WAVE" format identifier');

    }

    this.readDs64Chunk_(wavBuffer);

    this.readFmtChunk_(wavBuffer);

    this.readFactChunk_(wavBuffer);

    this.readBextChunk_(wavBuffer);

    this.readMextChunk_(wavBuffer);

    this.readCartChunk_(wavBuffer);

    this.readiXMLChunk_(wavBuffer);

    this.readCueChunk_(wavBuffer);

    this.readSmplChunk_(wavBuffer);

    this.readDataChunk_(wavBuffer, samples);

    this.readJunkChunk_(wavBuffer);

    this.readLISTChunk_(wavBuffer);

    this.read_PMXChunk_(wavBuffer);

  }

  /**

   * Reset the chunks of the WaveFileReader instance.

   * @protected

   * @ignore

   */

  clearHeaders() {

    /** @type {!Object} */

    let tmpWav = new WaveFileReader();

    Object.assign(this.fmt, tmpWav.fmt);

    Object.assign(this.fact, tmpWav.fact);

    Object.assign(this.cue, tmpWav.cue);

    Object.assign(this.smpl, tmpWav.smpl);

    Object.assign(this.bext, tmpWav.bext);

    Object.assign(this.mext, tmpWav.mext);

    Object.assign(this.cart, tmpWav.cart);

    Object.assign(this.iXML, tmpWav.iXML);

    Object.assign(this.ds64, tmpWav.ds64);

    Object.assign(this.data, tmpWav.data);

    this.LIST = [];

    Object.assign(this.junk, tmpWav.junk);

    Object.assign(this._PMX, tmpWav._PMX);

  }

  /**

   * Read the 'fmt ' chunk of a wave file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @throws {Error} If no 'fmt ' chunk is found.

   * @private

   */

  readFmtChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("fmt ");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.fmt.chunkId = chunk.chunkId;

      this.fmt.chunkSize = chunk.chunkSize;

      this.fmt.audioFormat = this.readUInt16_(buffer);

      this.fmt.numChannels = this.readUInt16_(buffer);

      this.fmt.sampleRate = this.readUInt32(buffer);

      this.fmt.byteRate = this.readUInt32(buffer);

      this.fmt.blockAlign = this.readUInt16_(buffer);

      this.fmt.bitsPerSample = this.readUInt16_(buffer);

      this.readFmtExtension_(buffer);

    } else {

      throw Error('Could not find the "fmt " chunk');

    }

  }

  /**

   * Read the 'fmt ' chunk extension.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readFmtExtension_(buffer) {

    if (this.fmt.chunkSize > 16) {

      this.fmt.cbSize = this.readUInt16_(buffer);

      if (this.fmt.audioFormat == 80 && this.fmt.chunkSize == 40) {

        this.fmt.headLayer = this.readUInt16_(buffer);

        this.fmt.headBitRate = this.readUInt32(buffer);

        this.fmt.headMode = this.readUInt16_(buffer);

        this.fmt.headModeExt = this.readUInt16_(buffer);

        this.fmt.headEmphasis = this.readUInt16_(buffer);

        this.fmt.headFlags = this.readUInt16_(buffer);

        this.fmt.ptsLow = this.readUInt32(buffer);

        this.fmt.ptsHigh = this.readUInt32(buffer);

      } else if (this.fmt.chunkSize > 18) {

        this.fmt.validBitsPerSample = this.readUInt16_(buffer);

        if (this.fmt.chunkSize > 20) {

          this.fmt.dwChannelMask = this.readUInt32(buffer);

          this.fmt.subformat = [

            this.readUInt32(buffer),

            this.readUInt32(buffer),

            this.readUInt32(buffer),

            this.readUInt32(buffer)

          ];

        }

      }

    }

  }

  /**

   * Read the 'fact' chunk of a wav file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readFactChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("fact");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.fact.chunkId = chunk.chunkId;

      this.fact.chunkSize = chunk.chunkSize;

      this.fact.dwSampleLength = this.readUInt32(buffer);

    }

  }

  /**

   * Read the 'cue ' chunk of a wave file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readCueChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("cue ");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.cue.chunkId = chunk.chunkId;

      this.cue.chunkSize = chunk.chunkSize;

      this.cue.dwCuePoints = this.readUInt32(buffer);

      for (let i = 0; i < this.cue.dwCuePoints; i++) {

        this.cue.points.push({

          dwName: this.readUInt32(buffer),

          dwPosition: this.readUInt32(buffer),

          fccChunk: this.readString(buffer, 4),

          dwChunkStart: this.readUInt32(buffer),

          dwBlockStart: this.readUInt32(buffer),

          dwSampleOffset: this.readUInt32(buffer)

        });

      }

    }

  }

  /**

   * Read the 'smpl' chunk of a wave file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readSmplChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("smpl");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.smpl.chunkId = chunk.chunkId;

      this.smpl.chunkSize = chunk.chunkSize;

      this.smpl.dwManufacturer = this.readUInt32(buffer);

      this.smpl.dwProduct = this.readUInt32(buffer);

      this.smpl.dwSamplePeriod = this.readUInt32(buffer);

      this.smpl.dwMIDIUnityNote = this.readUInt32(buffer);

      this.smpl.dwMIDIPitchFraction = this.readUInt32(buffer);

      this.smpl.dwSMPTEFormat = this.readUInt32(buffer);

      this.smpl.dwSMPTEOffset = this.readUInt32(buffer);

      this.smpl.dwNumSampleLoops = this.readUInt32(buffer);

      this.smpl.dwSamplerData = this.readUInt32(buffer);

      for (let i = 0; i < this.smpl.dwNumSampleLoops; i++) {

        this.smpl.loops.push({

          dwName: this.readUInt32(buffer),

          dwType: this.readUInt32(buffer),

          dwStart: this.readUInt32(buffer),

          dwEnd: this.readUInt32(buffer),

          dwFraction: this.readUInt32(buffer),

          dwPlayCount: this.readUInt32(buffer)

        });

      }

    }

  }

  /**

   * Read the 'data' chunk of a wave file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @param {boolean} samples True if the samples should be loaded.

   * @throws {Error} If no 'data' chunk is found.

   * @private

   */

  readDataChunk_(buffer, samples) {

    /** @type {?Object} */

    let chunk = this.findChunk("data");

    if (chunk) {

      this.data.chunkId = "data";

      this.data.chunkSize = chunk.chunkSize;

      if (samples) {

        this.data.samples = buffer.slice(

          chunk.chunkData.start,

          chunk.chunkData.end

        );

      }

    } else {

      throw Error('Could not find the "data" chunk');

    }

  }

  /**

   * Read the 'bext' chunk of a wav file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readBextChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("bext");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.bext.chunkId = chunk.chunkId;

      this.bext.chunkSize = chunk.chunkSize;

      this.bext.description = this.readString(buffer, 256);

      this.bext.originator = this.readString(buffer, 32);

      this.bext.originatorReference = this.readString(buffer, 32);

      this.bext.originationDate = this.readString(buffer, 10);

      this.bext.originationTime = this.readString(buffer, 8);

      this.bext.timeReference = [

        this.readUInt32(buffer),

        this.readUInt32(buffer)

      ];

      this.bext.version = this.readUInt16_(buffer);

      this.bext.UMID = this.readString(buffer, 64);

      this.bext.loudnessValue = this.readUInt16_(buffer);

      this.bext.loudnessRange = this.readUInt16_(buffer);

      this.bext.maxTruePeakLevel = this.readUInt16_(buffer);

      this.bext.maxMomentaryLoudness = this.readUInt16_(buffer);

      this.bext.maxShortTermLoudness = this.readUInt16_(buffer);

      this.bext.reserved = this.readString(buffer, 180);

      this.bext.codingHistory = this.readString(

        buffer,

        this.bext.chunkSize - 602

      );

    }

  }

  /**

   * Read the 'mext' chunk of a wav file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readMextChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("mext");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.mext.chunkId = chunk.chunkId;

      this.mext.chunkSize = chunk.chunkSize;

      this.mext.soundInformation = this.readUInt16_(buffer);

      this.mext.frameSize = this.readUInt16_(buffer);

      this.mext.ancillaryDataLength = this.readUInt16_(buffer);

      this.mext.ancillaryDataDef = this.readUInt16_(buffer);

      this.mext.reserved = this.readString(buffer, 4);

    }

  }

  /**

   * Read the 'cart' chunk of a wav file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readCartChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("cart");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.cart.chunkId = chunk.chunkId;

      this.cart.chunkSize = chunk.chunkSize;

      this.cart.version = this.readString(buffer, 4);

      this.cart.title = this.readString(buffer, 64);

      this.cart.artist = this.readString(buffer, 64);

      this.cart.cutId = this.readString(buffer, 64);

      this.cart.clientId = this.readString(buffer, 64);

      this.cart.category = this.readString(buffer, 64);

      this.cart.classification = this.readString(buffer, 64);

      this.cart.outCue = this.readString(buffer, 64);

      this.cart.startDate = this.readString(buffer, 10);

      this.cart.startTime = this.readString(buffer, 8);

      this.cart.endDate = this.readString(buffer, 10);

      this.cart.endTime = this.readString(buffer, 8);

      this.cart.producerAppId = this.readString(buffer, 64);

      this.cart.producerAppVersion = this.readString(buffer, 64);

      this.cart.userDef = this.readString(buffer, 64);

      this.cart.levelReference = this.readUInt32(buffer);

      this.cart.postTimer = [];

      for (let i = 0; i < 8; i++) {

        this.cart.postTimer.push({

          usage: this.readString(buffer, 4),

          value: this.readUInt32(buffer)

        });

      }

      this.cart.reserved = this.readString(buffer, 276);

      this.cart.url = this.readString(buffer, 1024);

      this.cart.tagText = this.readString(buffer, chunk.chunkSize - 2048);

    }

  }

  /**

   * Read the 'iXML' chunk of a wav file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readiXMLChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("iXML");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.iXML.chunkId = chunk.chunkId;

      this.iXML.chunkSize = chunk.chunkSize;

      this.iXML.value = unpackString(

        buffer,

        this.head,

        this.head + this.iXML.chunkSize

      );

    }

  }

  /**

   * Read the 'ds64' chunk of a wave file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @throws {Error} If no 'ds64' chunk is found and the file is RF64.

   * @private

   */

  readDs64Chunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("ds64");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this.ds64.chunkId = chunk.chunkId;

      this.ds64.chunkSize = chunk.chunkSize;

      this.ds64.riffSizeHigh = this.readUInt32(buffer);

      this.ds64.riffSizeLow = this.readUInt32(buffer);

      this.ds64.dataSizeHigh = this.readUInt32(buffer);

      this.ds64.dataSizeLow = this.readUInt32(buffer);

      this.ds64.originationTime = this.readUInt32(buffer);

      this.ds64.sampleCountHigh = this.readUInt32(buffer);

      this.ds64.sampleCountLow = this.readUInt32(buffer);

      //if (wav.ds64.chunkSize > 28) {

      //  wav.ds64.tableLength = unpack(

      //    chunkData.slice(28, 32), uInt32_);

      //  wav.ds64.table = chunkData.slice(

      //     32, 32 + wav.ds64.tableLength);

      //}

    } else {

      if (this.container == "RF64") {

        throw Error('Could not find the "ds64" chunk');

      }

    }

  }

  /**

   * Read the 'LIST' chunks of a wave file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readLISTChunk_(buffer) {

    /** @type {?Object} */

    let listChunks = this.findChunk("LIST", true);

    if (listChunks !== null) {

      for (let j = 0; j < listChunks.length; j++) {

        /** @type {!Object} */

        let subChunk = listChunks[j];

        this.LIST.push({

          chunkId: subChunk.chunkId,

          chunkSize: subChunk.chunkSize,

          format: subChunk.format,

          subChunks: []

        });

        for (let x = 0; x < subChunk.subChunks.length; x++) {

          this.readLISTSubChunks_(

            subChunk.subChunks[x],

            subChunk.format,

            buffer

          );

        }

      }

    }

  }

  /**

   * Read the sub chunks of a 'LIST' chunk.

   * @param {!Object} subChunk The 'LIST' subchunks.

   * @param {string} format The 'LIST' format, 'adtl' or 'INFO'.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readLISTSubChunks_(subChunk, format, buffer) {

    if (format == "adtl") {

      if (["labl", "note", "ltxt"].indexOf(subChunk.chunkId) > -1) {

        this.readLISTadtlSubChunks_(buffer, subChunk);

      }

      // RIFF INFO tags like ICRD, ISFT, ICMT

    } else if (format == "INFO") {

      this.readLISTINFOSubChunks_(buffer, subChunk);

    }

  }

  /**

   * Read the sub chunks of a 'LIST' chunk of type 'adtl'.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @param {!Object} subChunk The 'LIST' subchunks.

   * @private

   */

  readLISTadtlSubChunks_(buffer, subChunk) {

    this.head = subChunk.chunkData.start;

    /** @type {!Object<string, string|number>} */

    let item = {

      chunkId: subChunk.chunkId,

      chunkSize: subChunk.chunkSize,

      dwName: this.readUInt32(buffer)

    };

    if (subChunk.chunkId == "ltxt") {

      item.dwSampleLength = this.readUInt32(buffer);

      item.dwPurposeID = this.readUInt32(buffer);

      item.dwCountry = this.readUInt16_(buffer);

      item.dwLanguage = this.readUInt16_(buffer);

      item.dwDialect = this.readUInt16_(buffer);

      item.dwCodePage = this.readUInt16_(buffer);

      item.value = ""; // kept for compatibility

    } else {

      item.value = this.readZSTR_(buffer, this.head);

    }

    this.LIST[this.LIST.length - 1].subChunks.push(item);

  }

  /**

   * Read the sub chunks of a 'LIST' chunk of type 'INFO'.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @param {!Object} subChunk The 'LIST' subchunks.

   * @private

   */

  readLISTINFOSubChunks_(buffer, subChunk) {

    this.head = subChunk.chunkData.start;

    this.LIST[this.LIST.length - 1].subChunks.push({

      chunkId: subChunk.chunkId,

      chunkSize: subChunk.chunkSize,

      value: this.readZSTR_(buffer, this.head)

    });

  }

  /**

   * Read the 'junk' chunk of a wave file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  readJunkChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("junk");

    if (chunk) {

      this.junk = {

        chunkId: chunk.chunkId,

        chunkSize: chunk.chunkSize,

        chunkData: [].slice.call(

          buffer.slice(chunk.chunkData.start, chunk.chunkData.end)

        )

      };

    }

  }

  /**

   * Read the '_PMX' chunk of a wav file.

   * @param {!Uint8Array} buffer The wav file buffer.

   * @private

   */

  read_PMXChunk_(buffer) {

    /** @type {?Object} */

    let chunk = this.findChunk("_PMX");

    if (chunk) {

      this.head = chunk.chunkData.start;

      this._PMX.chunkId = chunk.chunkId;

      this._PMX.chunkSize = chunk.chunkSize;

      this._PMX.value = unpackString(

        buffer,

        this.head,

        this.head + this._PMX.chunkSize

      );

    }

  }

  /**

   * Read bytes as a ZSTR string.

   * @param {!Uint8Array} bytes The bytes.

   * @param {number=} [index=0] the index to start reading.

   * @return {string} The string.

   * @private

   */

  readZSTR_(bytes, index = 0) {

    for (let i = index; i < bytes.length; i++) {

      this.head++;

      if (bytes[i] === 0) {

        break;

      }

    }

    return unpackString(bytes, index, this.head - 1);

  }

  /**

   * Read a number from a chunk.

   * @param {!Uint8Array} bytes The chunk bytes.

   * @return {number} The number.

   * @private

   */

  readUInt16_(bytes) {

    /** @type {number} */

    let value = unpack(bytes, this.uInt16, this.head);

    this.head += 2;

    return value;

  }

}